<?php

Class Helper_Array{
	/**
	 * 将一个二维数组的第一维和第二维交换
	 * 
	 * 例如将
	 * array(
	 * 		0 => array('name' => 'John', 'age'=>10),
	 * 		1 => array('name' => 'Emma', 'age'=>14)
	 * )
	 * 
	 * 转化为:
	 * array(
	 * 		'name' => array('John','Emma'),
	 * 		'age'  => array(10,14)
	 * }
	 * @param array $source_arr
	 * @return array
	 */
	function ds(&$source_arr){
		if (!is_array($source_arr)) {
			return array();
		}
		foreach ($source_arr as $akey => $bArr){
			foreach ($bArr as $bKey => $value){
				$ret[$bKey][$akey] = $value;
			}
		}
		return $ret;
	}
	
	/**
	 * 将一个二维数组按照指定字段的值分组
	 *
	 * @param array $arr
	 * @param string $keyField
	 *
	 * @return array
	 */
	static function group_by($arr, $keyField)
	{
	    $ret = array();
	    foreach ($arr as $row) {
	        $key = $row[$keyField];
	        $ret[$key][] = $row;
	    }
	    return $ret;
	}
	/**
	 * Revome the values in the array which match the given values.
	 *
	 * @param mix $values    要搜索的值
	 * @param array $array  被搜索的数组
	 * @param bool $strict 如果strict为 true,将检查变量类型
	 * 
	 * @return 删除后剩下的元素
	 */
	
	static function remove_by_value($values,$array,$strict=false)
	{
		$remove = array();
		
		!is_array($values) && $values = array($values);
		if (!is_array($array)) {
			$array = array($array);
		}
		foreach ($array as $key => $item){
			if (in_array($item,$values,$strict)) {
				$remove[$key] = $item;
				unset($array[$key]);
			}
		}
		return $array;
	}
	/**
	 * 查找几个数组中相同的元素
	 *
	 * @param array $array1
	 * @param array $array2
	 * 
	 * @return array
	 */
	static function get_same_elements($array1,$array2)
	{
		$array_list = func_get_args();
		$limit = func_num_args() - 1;
		for ($i=0; $i<$limit; $i++){
			if (count($array_list[$i]) == 0) {
				break;
			}
			foreach ($array_list[$i+1] as $key => $element){
				if (!in_array($element, $array_list[$i])) {
					unset($array_list[$i+1][$key]);
				}
			}
		}
		$ret = $array_list[$i];
		sort($ret);
		return $ret;
		
	}
	/**
	 * 从数组中删除空白的元素（包括只有空白字符的元素）
	 *
	 * @param array $arr
	 * @param boolean $trim
	 */
	static function remove_empty(& $arr, $trim = true)
	{
	    foreach ($arr as $key => $value) {
	        if (is_array($value)) {
	            self::remove_empty($arr[$key]);
	        } else {
	            $value = trim($value);
	            if ($value == '') {
	                unset($arr[$key]);
	            } elseif ($trim) {
	                $arr[$key] = $value;
	            }
	        }
	    }
	}
	
	/**
	 * 从一个二维数组中返回指定键的所有值
	 *
	 * @param array $arr
	 * @param string $col
	 *
	 * @return array
	 */
	static function col_values(& $arr, $col)
	{
	    $ret = array();
	    foreach ($arr as $row) {
	        if (isset($row[$col])) { $ret[] = $row[$col]; }
	    }
	    return $ret;
	}
	
	/**
	 * 将一个二维数组转换为 hashmap
	 *
	 * 如果省略 $valueField 参数，则转换结果每一项为包含该项所有数据的数组。
	 *
	 * @param array $arr
	 * @param string $keyField
	 * @param string $valueField
	 *
	 * @return array
	 */
	static function to_hashmap(& $arr, $keyField, $valueField = null)
	{
	    $ret = array();
	    if ($valueField) {
	        foreach ($arr as $row) {
	            $ret[$row[$keyField]] = $row[$valueField];
	        }
	    } else {
	        foreach ($arr as $row) {
	            $ret[$row[$keyField]] = $row;
	        }
	    }
	    return $ret;
	}
	
	
	/**
	 * 将一个平面的二维数组按照指定的字段转换为树状结构
	 *
	 * 当 $returnReferences 参数为 true 时，返回结果的 tree 字段为树，refs 字段则为节点引用。
	 * 利用返回的节点引用，可以很方便的获取包含以任意节点为根的子树。
	 *
	 * @param array $arr 原始数据
	 * @param string $fid 节点ID字段名
	 * @param string $fparent 节点父ID字段名
	 * @param string $fchildrens 保存子节点的字段名
	 * @param boolean $returnReferences 是否在返回结果中包含节点引用
	 *
	 * return array
	 */
	static function to_tree($arr, $fid, $fparent = 'parent_id',
	    $fchildrens = 'childrens', $returnReferences = false)
	{
	    $pkvRefs = array();
	    foreach ($arr as $offset => $row) {
	        $pkvRefs[$row[$fid]] =& $arr[$offset];
	    }
	
	    $tree = array();
	    foreach ($arr as $offset => $row) {
	        $parentId = $row[$fparent];
	        if ($parentId) {
	            if (!isset($pkvRefs[$parentId])) { continue; }
	            $parent =& $pkvRefs[$parentId];
	            $parent[$fchildrens][] =& $arr[$offset];
	        } else {
	            $tree[] =& $arr[$offset];
	        }
	    }
	    if ($returnReferences) {
	        return array('tree' => $tree, 'refs' => $pkvRefs);
	    } else {
	        return $tree;
	    }
	}
	
	/**
	 * 将树转换为平面的数组
	 *
	 * @param array $node
	 * @param string $fchildrens
	 *
	 * @return array
	 */
	static function tree_to_array(& $node, $fchildrens = 'childrens')
	{
	    $ret = array();
	    if (isset($node[$fchildrens]) && is_array($node[$fchildrens])) {
	        foreach ($node[$fchildrens] as $child) {
	            $ret = array_merge($ret, self::tree_to_array($child, $fchildrens));
	        }
	        unset($node[$fchildrens]);
	        $ret[] = $node;
	    } else {
	        $ret[] = $node;
	    }
	    return $ret;
	}
	
	/**
	 * 根据指定的键值对数组排序
	 *
	 * @param array $array 要排序的数组
	 * @param string $keyname 键值名称
	 * @param int $sortDirection 排序方向
	 *
	 * @return array
	 */
	static function column_sort($array, $keyname, $sortDirection = SORT_ASC)
	{
	    return self::sortby_multifields($array, array($keyname => $sortDirection));
	}
	
	/**
	 * 将一个二维数组按照指定列进行排序，类似 SQL 语句中的 ORDER BY
	 *
	 * @param array $rowset
	 * @param array $args
	
	 * @return array
	 */
	static function sortby_multifields($rowset, $args)
	{
	    $sortArray = array();
	    $sortRule = '';
	    foreach ($args as $sortField => $sortDir) {
	        foreach ($rowset as $offset => $row) {
	            $sortArray[$sortField][$offset] = $row[$sortField];
	        }
	        $sortRule .= '$sortArray[\'' . $sortField . '\'], ' . $sortDir . ', ';
	    }
	    if (empty($sortArray) || empty($sortRule)) { return $rowset; }
	    eval('array_multisort(' . $sortRule . '$rowset);');
	    return $rowset;
	}
	
	
	/**
	 * 将一个二维数组按照指定列进行自然排序
	 *
	 * @param array $rowset
	 * @param array $keyname
	 *
	 * @return array
	 */
	
	static function column_natsort(&$rowset,$keyname)
	{
		$cnt = count($rowset);
		for($i = 0; $i<$cnt; $i++ ){
			for($j=0;$j<$cnt-$i-1;$j++){
				if(strnatcmp($rowset[$j][$keyname],$rowset[$j+1][$keyname]) > 0 ){
					$tmp = $rowset[$j][$keyname];
					$rowset[$j][$keyname] = $rowset[$j+1][$keyname];
					$rowset[$j+1][$keyname] = $tmp;
				}
			}
		}
	    return $rowset;
	}
}
class Test_Helper_Array
{
	function test_get_same_elements(){
		//Test 1;
		$array1 = array("2","6","9","13");
		$array2 = array("2","6","9","13");
		$array3 = array("2","6","9","13");
		$result = Helper_Array::get_same_elements($array3,$array2,$array1);
		if($result === $array1){
			echo "PASS\n";
		}
		//Test 2;
		$array2 = array("9","13");
		$array3 = array("2","6");
		$result = Helper_Array::get_same_elements($array3,$array2,$array1);
		if($result === array()){
			echo "PASS\n";
		}		
		//Test 3;
		$array2 = array("6");
		$array3 = array("2","6");
		$result = Helper_Array::get_same_elements($array3,$array2,$array1);
		if($result === array("6")){
			echo "PASS\n";
		}	
		//Test 4;
		$array2 = array();
		$array3 = array("2","6");
		$result = Helper_Array::get_same_elements($array3,$array2,$array1);
		if($result === array()){
			echo "PASS\n";
		}			
	}
	
	function test_to_array(){
		$array[] = array(
			"id"	=>		1,
			"pid"	=>		0,
			"name"	=>		"child of 1"
		);
		$array[] = array(
			"id"	=>		2,
			"pid"	=>		1,
			"name"	=>		"child of 1"
		);
		$array[] = array(
			"id"	=>		4,
			"pid"	=>		2,
			"name"	=>		"child of 2"
		);
		
		print_r(Helper_Array::to_tree($array,'id','pid',"childrens",true));
	}
}